// index.js
const app = getApp()

Page({
  /**
   * 页面数据
   */
  data: {
    list: [],          // 礼单列表
    keyword: '',       // 搜索关键词
    page: 0,           // 当前页码
    hasMore: true,     // 是否有更多数据
    loading: false,    // 是否加载中
    totalCount: 0,     // 总记录数
    searchTimer: null, // 搜索防抖定时器
    openid: null,      // 用户openid
    totalAmount: '0.00',    // 总礼金金额
    returnedCount: 0,  // 已回礼人数
    notReturnedCount: 0, // 未回礼人数
    isFocused: false,  // 搜索框是否聚焦
    startX: 0,         // 触摸开始位置
    startY: 0,         // 触摸开始Y位置
    statusFilter: 'all', // 回礼状态筛选：all-全部，returned-已回礼，notReturned-未回礼
    displayList: [],   // 筛选后显示的列表
    filteredPage: 0,   // 筛选后的当前页码
    hasFilteredMore: true, // 是否有更多筛选后的数据
    filteredTotal: 0,   // 筛选后的总记录数
    returnedAmount: '0.00',       // 已回礼总额
    notReturnedAmount: '0.00',    // 未回礼总额
    pageSize: 20,            // 每页记录数
    filterPageSize: 20,      // 筛选列表的每页记录数
    avatarUrl: './user-unlogin.png',
    userInfo: null,
    logged: false,
    takeSession: false,
    requestResult: '',
    canIUseGetUserProfile: false,
    canIUseOpenData: false,
    total: 0,
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad() {
    console.log('页面加载，开始请求数据')
    this.getOpenidAndLoadData()
  },
  
  /**
   * 获取openid并加载数据
   */
  getOpenidAndLoadData() {
    // 从全局获取openid
    if (app.globalData.openid) {
      console.log('从App获取到openid')
      this.setData({ openid: app.globalData.openid })
      this.loadDataFromCloud() // 使用新方法从云函数加载数据
      return
    }
    
    // 如果未获取到，定时检查
    const checkOpenid = setInterval(() => {
      if (app.globalData.openid) {
        console.log('通过轮询获取到openid')
        this.setData({ openid: app.globalData.openid })
        this.loadDataFromCloud() // 使用新方法从云函数加载数据
        clearInterval(checkOpenid)
      }
    }, 300)
    
    // 2秒后如仍未获取到，直接调用云函数
    setTimeout(() => {
      if (!this.data.openid) {
        console.log('定时器触发，直接获取openid')
        this.getOpenidDirectly()
        clearInterval(checkOpenid)
      }
    }, 2000)
  },
  
  /**
   * 直接调用云函数获取openid
   */
  async getOpenidDirectly() {
    wx.showLoading({ title: '加载中...' })
    
    try {
      const { result } = await wx.cloud.callFunction({
        name: 'login'
      })
      
      wx.hideLoading()
      
      if (result && result.openid) {
        console.log('获取到openid')
        this.setData({ openid: result.openid })
        app.globalData.openid = result.openid
        
        // 加载数据
        this.loadDataFromCloud() // 使用新方法从云函数加载数据
        
        // 检查用户是否存在
        this.checkAndCreateUser(result.openid)
      } else {
        wx.showToast({
          title: '获取用户信息失败',
          icon: 'none'
        })
      }
    } catch (err) {
      wx.hideLoading()
      console.error('获取openid失败', err)
      wx.showToast({
        title: '获取用户信息失败',
        icon: 'none'
      })
    }
  },
  
  /**
   * 检查并创建用户
   */
  async checkAndCreateUser(openid) {
    try {
      const db = wx.cloud.database()
      const userRes = await db.collection('users').where({
        openid: openid
      }).get()
      
      // 如果用户不存在，则创建
      if (userRes.data.length === 0) {
        console.log('用户不存在，添加到数据库')
        await db.collection('users').add({
          data: {
            openid: openid,
            create_time: db.serverDate()
          }
        })
      }
    } catch (err) {
      console.error('检查用户是否存在失败', err)
    }
  },
  
  /**
   * 从云函数加载数据
   */
  async loadDataFromCloud() {
    if (!this.data.openid) return
    
    this.setData({ loading: true })
    
    try {
      console.log(`从云函数加载数据: 关键词=${this.data.keyword || '无'}, 筛选=${this.data.statusFilter}, 页码=${this.data.statusFilter === 'all' ? this.data.page : this.data.filteredPage}`)
      
      // 调用云函数获取数据
      wx.cloud.callFunction({
        name: 'getGiftStatistics',
        data: {
          mode: 'all', // 一次性获取统计数据和列表数据
          keyword: this.data.keyword,
          statusFilter: this.data.statusFilter,
          page: this.data.statusFilter === 'all' ? this.data.page : this.data.filteredPage,
          pageSize: 40 // 增加页面大小，确保加载足够多的记录
        }
      }).then(({ result }) => {
        console.log('云函数返回数据:', result)
        
        // 更新统计数据
        if (result.totalStatistics) {
          this.setData({
            totalCount: result.totalStatistics.totalCount || 0,
            totalAmount: result.totalStatistics.totalAmount || '0.00',
            returnedCount: result.totalStatistics.returnedCount || 0,
            returnedAmount: result.totalStatistics.returnedAmount || '0.00',
            notReturnedCount: result.totalStatistics.notReturnedCount || 0,
            notReturnedAmount: result.totalStatistics.notReturnedAmount || '0.00'
          })
        }
      
        // 处理列表数据
        if (this.data.statusFilter === 'all') {
          // 更新主列表
          const newList = this.data.page === 0 ? 
            result.list : 
            [...this.data.list, ...result.list]
            
          this.setData({
            list: newList,
            hasMore: result.hasMore,
            loading: false
          })
        } else {
          // 更新筛选列表
          const newList = this.data.filteredPage === 0 ? 
            result.list : 
            [...this.data.displayList, ...result.list]
            
          this.setData({
            displayList: newList,
            hasFilteredMore: result.hasMore,
            loading: false
          })
        }
      }).catch(err => {
        console.error('从云函数加载数据失败', err)
        this.setData({ loading: false })
        wx.showToast({
          title: '加载失败',
          icon: 'none'
        })
      })
      
    } catch (err) {
      console.error('处理加载数据异常', err)
      this.setData({ loading: false })
    }
  },
  
  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    console.log('页面显示')
    
    // 如果已经有openid，则刷新数据
    if (this.data.openid) {
      this.resetItemPositions() // 重置所有滑动位置
      this.setData({
        list: [],
        displayList: [],
        page: 0,
        hasMore: true,
        statusFilter: 'all', // 重置筛选状态为"全部"
        filteredPage: 0,
        hasFilteredMore: true
      })
      this.loadDataFromCloud() // 使用新方法加载数据
    } else {
      this.getOpenidAndLoadData()
    }
  },
  
  /**
   * 跳转到添加页面
   */
  navigateToAdd() {
    wx.navigateTo({
      url: '/pages/add/add'
    })
  },

  /**
   * 获取数据总条数
   */
  async countTotal() {
    if (!this.data.openid) return;
    
    try {
      const db = wx.cloud.database();
      let query = { openid: this.data.openid };
      
      // 如果有搜索关键词，添加到查询条件
      if (this.data.keyword) {
        query.name = db.RegExp({
          regexp: this.data.keyword,
          options: 'i'
        });
      }
      
      const res = await db.collection('gift_list').where(query).count();
      console.log('总记录数:', res.total);
      this.setData({ totalCount: res.total });
    } catch (err) {
      console.error('计算总数失败', err);
    }
  },

  /**
   * 下拉刷新处理
   */
  onPullDownRefresh() {
    this.setData({
      list: [],
      page: 0,
      hasMore: true
    })
    
    this.loadDataFromCloud().then(() => {
      wx.stopPullDownRefresh()
    })
  },

  /**
   * 清除搜索内容
   */
  clearKeyword() {
    this.setData({ 
      keyword: '',
      list: [],
      page: 0,
      hasMore: true
    })
    this.loadDataFromCloud()
  },

  /**
   * 输入框内容变化处理（带防抖）
   */
  onInput(e) {
    const keyword = e.detail.value
    this.setData({ keyword })
    
    // 清除之前的定时器
    if (this.data.searchTimer) {
      clearTimeout(this.data.searchTimer)
    }
    
    // 设置300ms防抖
    const timer = setTimeout(() => {
      this.setData({ 
        list: [],
        page: 0,
        hasMore: true
      })
      this.loadDataFromCloud()
    }, 300)
    
    this.setData({ searchTimer: timer })
  },

  /**
   * 查询按钮点击
   */
  searchGift() {
    if (this.data.searchTimer) {
      clearTimeout(this.data.searchTimer)
    }
    
    this.setData({ 
      list: [],
      page: 0,
      hasMore: true
    })
    this.loadDataFromCloud()
  },

  /**
   * 滚动到底部触发
   */
  onReachBottom() {
    console.log('触底加载更多');
    
    if (this.data.loading) {
      return;
    }
    
    // 增加页码
    if (this.data.statusFilter === 'all') {
      this.setData({
        page: this.data.page + 1
      });
    } else {
      this.setData({
        filteredPage: this.data.filteredPage + 1
      });
    }
    
    // 根据筛选状态决定加载哪种数据
    if (this.data.statusFilter === 'all') {
      // 全部状态加载主列表
      if (this.data.hasMore) {
        console.log('加载全部数据');
        this.loadDataFromCloud();
      }
    } else {
      // 筛选状态(已回礼)加载筛选列表
      if (this.data.hasFilteredMore) {
        console.log('加载筛选数据:', this.data.statusFilter);
        this.loadDataFromCloud();
      }
    }
  },

  /**
   * 点击礼单进行编辑
   */
  editGift(e) {
    // 检查是否有滑动的礼单项，有则先重置
    const hasSlideItem = this.data.list.some(item => item.isTouchMove);
    if (hasSlideItem) {
      this.resetItemPositions();
      return; // 重置后不执行编辑操作，避免误触
    }

    const { id, item } = e.currentTarget.dataset
    
    wx.navigateTo({
      url: `/pages/edit/edit?id=${id}&name=${item.name}&amount=${item.amount || ''}&is_return_gift=${item.is_return_gift ? 'true' : 'false'}`
    })
  },
  
  /**
   * 阻止事件冒泡
   */
  stopPropagation(e) {
    // 在Skyline渲染引擎下，e.stopPropagation不是函数
    // 改为使用catchtap而不是调用此函数
    return false
  },

  /**
   * 搜索框获取焦点
   */
  onSearchFocus() {
    this.setData({
      isFocused: true
    })
  },

  /**
   * 搜索框失去焦点
   */
  onSearchBlur() {
    this.setData({
      isFocused: false
    })
  },

  /**
   * 处理礼单触摸结束事件
   */
  handleGiftTouchEnd(e) {
    const { index } = e.currentTarget.dataset
    const x = e.detail.x
    
    console.log(`礼单滑动触摸结束: index=${index}, x=${x}`)
    
    // 滑动超过阈值时，显示操作按钮
    let list = [...this.data.list]
    if (x < -30) {
      list[index].x = -240
    } else {
      list[index].x = 0
    }
    this.setData({ list })
  },

  /**
   * 重置所有滑动项的位置
   */
  resetItemPositions() {
    // 检查是否有list数据，避免错误
    if (!this.data.list || this.data.list.length === 0) return;
    
    console.log('正在重置所有项的位置');
    
    // 重置主列表
    let list = [...this.data.list];
    list.forEach(item => {
      if (item) {
        item.isTouchMove = false;
      }
    });
    
    // 如果有筛选列表，也进行重置
    let displayList = [];
    if (this.data.statusFilter !== 'all' && this.data.displayList && this.data.displayList.length > 0) {
      displayList = [...this.data.displayList];
      displayList.forEach(item => {
        if (item) {
          item.isTouchMove = false;
        }
      });
    }
    
    this.setData({ 
      list,
      displayList
    });
  },

  /**
   * 点击页面其他区域时重置所有滑动项
   */
  onPageTap() {
    // 检查是否有滑动的项
    let hasSlideItem = false;
    if (this.data.list && this.data.list.length > 0) {
      hasSlideItem = this.data.list.some(item => item.isTouchMove);
    }
    
    if (hasSlideItem) {
      console.log("页面点击，检测到有滑动项，重置所有滑动项");
      this.resetItemPositions();
    }
  },

  /**
   * 删除礼单
   */
  async deleteGift(e) {
    const { id, index } = e.currentTarget.dataset
    
    // 如果 index 是 undefined，通过 id 查找对应的索引
    let realIndex = index
    if (realIndex === undefined && id) {
      realIndex = this.findIndexById(this.data.list, id)
      console.log(`删除操作：通过 id 查找到的索引为: ${realIndex}`)
    }
    
    // 如果依然找不到索引，给出错误提示并返回
    if (realIndex === undefined || realIndex === -1) {
      console.error('无法找到对应的礼单项，无法删除')
      wx.showToast({
        title: '操作失败，请刷新后重试',
        icon: 'none',
        duration: 2000
      })
      return
    }
    
    // 确认删除
    const res = await wx.showModal({
      title: '确认删除',
      content: '确定要删除这条礼单记录吗？',
      confirmColor: '#f56565'
    })
    
    if (res.confirm) {
      wx.showLoading({ title: '删除中...' })
      
      try {
        const db = wx.cloud.database()
        await db.collection('gift_list').doc(id).remove()
        
        // 更新本地数据
        let list = [...this.data.list]
        list.splice(realIndex, 1)
        this.setData({ list })
        
        // 同时更新筛选列表（如果在筛选状态）
        if (this.data.statusFilter !== 'all') {
          const filteredIndex = this.findIndexById(this.data.displayList, id)
          if (filteredIndex !== -1) {
            const displayList = [...this.data.displayList]
            displayList.splice(filteredIndex, 1)
            this.setData({ displayList })
          }
        }
        
        // 重新加载统计数据
        this.loadDataFromCloud()
        
        wx.hideLoading()
        wx.showToast({ 
          title: '删除成功',
          icon: 'success'
        })
      } catch (err) {
        wx.hideLoading()
        wx.showToast({
          title: '删除失败',
          icon: 'none'
        })
        console.error('删除礼单失败', err)
      }
    }
    
    // 无论确认还是取消，都恢复所有项目位置
    this.resetItemPositions()
  },

  /**
   * 触摸开始事件
   */
  touchStart(e) {
    // 记录起始点的坐标
    this.setData({
      startX: e.touches[0].clientX,
      startY: e.touches[0].clientY
    });
    
    // 根据是否筛选选择对应的列表
    const currentList = this.data.statusFilter === 'all' ? this.data.list : this.data.displayList;
    
    // 重置所有项目的滑动状态
    let updatedList = [...currentList];
    updatedList.forEach(item => {
      if (item.isTouchMove) {
        item.isTouchMove = false;
      }
    });
    
    if (this.data.statusFilter === 'all') {
      this.setData({ list: updatedList });
    } else {
      this.setData({ displayList: updatedList });
      
      // 同时更新主列表中对应的项
      const mainList = [...this.data.list];
      updatedList.forEach(item => {
        const index = mainList.findIndex(mainItem => mainItem._id === item._id);
        if (index !== -1) {
          mainList[index].isTouchMove = item.isTouchMove;
        }
      });
      this.setData({ list: mainList });
    }
  },
  
  /**
   * 触摸移动事件
   */
  touchMove(e) {
    const index = e.currentTarget.dataset.index;
    let startX = this.data.startX;
    let startY = this.data.startY;
    let touchMoveX = e.touches[0].clientX;
    let touchMoveY = e.touches[0].clientY;
    
    // 计算角度，判断是否为水平滑动
    let angle = this.angle({ X: startX, Y: startY }, { X: touchMoveX, Y: touchMoveY });
    
    // 如果角度大于30度，则不是水平滑动
    if (Math.abs(angle) > 30) return;
    
    // 根据是否筛选选择对应的列表
    const currentList = this.data.statusFilter === 'all' ? this.data.list : this.data.displayList;
    
    // 更新滑动状态
    let updatedList = [...currentList];
    
    // 判断是左滑还是右滑
    if (touchMoveX < startX) { // 左滑
      updatedList[index].isTouchMove = true; // 显示删除按钮
    } else { // 右滑
      updatedList[index].isTouchMove = false; // 隐藏删除按钮
    }
    
    if (this.data.statusFilter === 'all') {
      this.setData({ list: updatedList });
    } else {
      this.setData({ displayList: updatedList });
      
      // 同时更新主列表中对应的项
      const mainList = [...this.data.list];
      const item = updatedList[index];
      const mainIndex = mainList.findIndex(mainItem => mainItem._id === item._id);
      if (mainIndex !== -1) {
        mainList[mainIndex].isTouchMove = item.isTouchMove;
      }
      this.setData({ list: mainList });
    }
  },
  
  /**
   * 计算滑动角度
   * @param {Object} start 起点坐标
   * @param {Object} end 终点坐标
   */
  angle(start, end) {
    let _X = end.X - start.X;
    let _Y = end.Y - start.Y;
    
    // 计算两点间的角度
    return 360 * Math.atan(_Y / _X) / (2 * Math.PI);
  },

  /**
   * 状态筛选切换
   */
  onFilterStatusChange(e) {
    const status = e.currentTarget.dataset.status;
    console.log(`切换状态筛选: ${status}`);
    
    // 如果点击当前已选中的筛选项，不做操作
    if (status === this.data.statusFilter) {
      return;
    }
    
    // 重置分页状态
    this.setData({
      statusFilter: status,
      filteredPage: 0,    // 筛选后的页码
      hasFilteredMore: true, // 是否有更多筛选数据
      displayList: []     // 清空显示列表
    });
    
    // 重置滚动位置
    if (wx.pageScrollTo) {
      wx.pageScrollTo({
        scrollTop: 0
      });
    }
    
    // 加载数据
    this.loadDataFromCloud();
  },

  /**
   * 通过 ID 查找列表中的索引
   */
  findIndexById(list, id) {
    for (let i = 0; i < list.length; i++) {
      if (list[i]._id === id) {
        return i;
      }
    }
    return -1;
  },

  /**
   * 更新礼单回礼状态
   */
  async toggleStatus(e) {
    const { id, index, status } = e.currentTarget.dataset
    console.log(`开始更新回礼状态: id=${id}, index=${index}, status=${status}, 当前页=${this.data.page}, 筛选状态=${this.data.statusFilter}`)
    
    // 获取需要操作的列表和索引
    let targetList, realIndex, currentItem
    
    if (this.data.statusFilter === 'all') {
      // 全部状态下，直接使用主列表和传入的索引
      targetList = this.data.list
      realIndex = index
      currentItem = targetList[realIndex]
    } else {
      // 筛选状态下，先获取筛选列表中的当前项
      currentItem = this.data.displayList[index]
      if (!currentItem || !currentItem._id) {
        console.error('无法找到要操作的记录')
        wx.showToast({
          title: '操作失败，请刷新后重试',
          icon: 'none',
          duration: 2000
        })
        return
      }
      
      // 尝试在主列表中查找对应的索引
      targetList = this.data.list
      realIndex = this.findIndexById(targetList, currentItem._id)
    }
    
    // 准备本地数据更新 
    let shouldUpdateMainList = true
    let newList = null
    
    // 检查是否在主列表中找到对应项
    if (realIndex === undefined || realIndex === -1) {
      console.log('在主列表中未找到对应项，可能是分页加载导致。将只更新筛选视图和数据库')
      shouldUpdateMainList = false
    } else {
      // 在主列表中找到了，可以更新
      newList = [...targetList]
      newList[realIndex].is_return_gift = status
      this.setData({ list: newList })
    }
    
    // 更新筛选列表中的状态
    if (this.data.statusFilter !== 'all') {
      const displayList = [...this.data.displayList]
      displayList[index].is_return_gift = status
      this.setData({ displayList })
    }
    
    try {
      // 调用云函数更新状态
      console.log('调用云函数toggleGiftStatus...')
      const { result } = await wx.cloud.callFunction({
        name: 'toggleGiftStatus',
        data: { 
          id,
          status
        }
      })
      
      console.log('云函数返回结果:', result)
      
      if (result.success) {
        wx.showToast({
          title: result.message,
          icon: 'success',
          duration: 1500
        })
        
        // 更新本地统计数据
        if (result.stats) {
          console.log('更新本地统计数据:', result.stats)
          this.setData({
            totalCount: result.stats.totalCount || 0,
            totalAmount: result.stats.totalAmount || '0.00',
            returnedCount: result.stats.returnedCount || 0,
            notReturnedCount: result.stats.notReturnedCount || 0
          })
        }
        
        // 如果在筛选模式下且状态发生变化，需要从列表中移除此项
        if (this.data.statusFilter === 'returned' && !status) {
          // 当前是已回礼筛选，但切换为未回礼，则需从列表中移除
          const updatedDisplayList = [...this.data.displayList]
          updatedDisplayList.splice(index, 1)
          this.setData({ displayList: updatedDisplayList })
          
          // 可能需要加载更多数据以填充
          if (this.data.hasFilteredMore && updatedDisplayList.length < 20) {
            // 重置页面数据状态，确保从服务器加载新数据
            this.setData({
              filteredPage: 0,
              hasFilteredMore: true
            })
            // 重新加载筛选数据
            this.loadDataFromCloud()
          }
        }
      } else {
        // 更新失败，回滚状态
        console.error('云函数返回更新失败:', result.message)
        
        // 如果之前更新了主列表，需要回滚
        if (shouldUpdateMainList && newList) {
          newList[realIndex].is_return_gift = !status
          this.setData({ list: newList })
        }
        
        // 回滚筛选列表状态
        if (this.data.statusFilter !== 'all') {
          const displayList = [...this.data.displayList]
          displayList[index].is_return_gift = !status
          this.setData({ displayList })
        }
        
        wx.showToast({
          title: result.message || '更新失败',
          icon: 'none',
          duration: 2000
        })
      }
    } catch (err) {
      // 更新失败，回滚状态
      console.error('更新状态失败:', err)
      
      // 如果之前更新了主列表，需要回滚
      if (shouldUpdateMainList && newList) {
        newList[realIndex].is_return_gift = !status
        this.setData({ list: newList })
      }
      
      // 回滚筛选列表状态
      if (this.data.statusFilter !== 'all') {
        const displayList = [...this.data.displayList]
        displayList[index].is_return_gift = !status
        this.setData({ displayList })
      }
      
      wx.showToast({
        title: '更新失败',
        icon: 'none',
        duration: 2000
      })
    }
  },
})
